package com.shujia.scala

import java.util

object Demo19List {
  def main(args: Array[String]): Unit = {

    /**
     * list: 有序不唯一集合
     * set：无序唯一集合
     * map：kv格式的集合
     * tuple：元组,固定长度集合
     *
     */

    //默认构建额是一个不可变的集合
    val list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 1, 1, 2)

    println(list)

    /**
     * 再scala集合中提供了很多很好用的方法
     *
     */
    println(list.mkString(",")) //通过一个分隔符将集合拼接成一个字符串
    println(list.max) //取最大值
    println(list.min) //取最小值
    println(list.sum) //求和
    println(list.length) //获取元素数量
    println(list.reverse) //反转集合,返回一个新的集合
    println(list.distinct) //去重,返回一个新的集合
    println(list(0)) //通过下标获取数据
    println(list.head) //获取第一个元素
    println(list.last) //获取最后一个元素
    println(list.take(5)) //取前top数据
    println(list.tail) //获取不包含第一个元素后面所有的元素

    println("=" * 100)

    /**
     * 1、foreach:循环集合将集合中的元素一个一个传递给后面的函数
     *
     */
    list.foreach((i: Int) => println(i))


    /**
     * 2、map方法, 循环集合中的元素一个一个传递给后面的函数， 将函数的返回值构建成一个新的集合
     */
    //多集合中的每一个元素加1
    val ints = new util.ArrayList[Int]()
    for (i <- list) {
      val j: Int = i + 1
      ints.add(j)
    }
    println(ints)

    val mapList: List[Int] = list.map((i: Int) => i * i)
    println(mapList)


    println("=" * 100)

    val lines: List[String] = List("java,spark,hadoop", "java,hadoop", "scala,hadoop")
    //将一行中的多个单词拆分出来，每个单词作为一行
    val javaWords = new util.ArrayList[String]()
    for (line <- lines) {
      val split: Array[String] = line.split(",")
      for (word <- split) {
        javaWords.add(word)
      }
    }
    println(javaWords)

    /**
     * 3、flatmap:循环集合中的元素，将元素一个一个传递给后面的函数， flatmap会将函数返回的集合展开构建成一个新的集合
     * 相当于sql中的explode
     */
    //scala写法
    val words: List[String] = lines.flatMap((line: String) => line.split(","))
    println(words)


    /**
     * 4、filter: 循环集合中的元素一个一个传递给后面的函数，如果函数返回true保留数据，如果函数返回false过滤数据
     *
     */
    //取出集合中的奇数
    val ints1 = new util.ArrayList[Int]()
    for (i <- list) {
      if (i % 2 == 1) {
        ints1.add(i)
      }
    }
    println(ints1)

    //scala写法
    val filterList: List[Int] = list.filter((i: Int) => i % 2 == 1)
    println(filterList)


    /**
     * 5、sort: 对集合中的元素排序，默认是升序
     *
     */
    //sortBy指定一个排序的字段
    val sortByList: List[Int] = list.sortBy((i: Int) => -i)
    println(sortByList)

    //sortWith指定一个排序的规则
    val sortWithList: List[Int] = list.sortWith((i: Int, j: Int) => i < j)
    println(sortWithList)


    /**
     * 6、groupBy: 通过一个字段进行分组，返回一个map集合
     *
     */
    println(words)

    val groupByMap: Map[String, List[String]] = words.groupBy((word: String) => word)
    println(groupByMap)

    /**
     * 1、foreach: 遍历数据，没有返回值
     * 2、map:用于对集合中的元素做处理方法，传入一行返回一行
     * 3、flatMap： 将一行转换成多行
     * 4、filter: 过滤数据，数据会变少
     * 5、sortBy sortWith 对数据排序，不会改变数据量，之后改变数据的顺序
     * 6、groupBy : 分组，将同一个key分到同一个组内，数据行数会变少
     *
     */

  }

}
